I am not a TypeScript expert but this works for me. Please let me know what you think and thanks for this very useful extension :)

To try out these typings in your project, you can temporarily add

yarn add https://github.com/saraedum/vue-async-computed\#87a833fdd0a89f48d1fb675b3899356d0599fdf2

instead of vue-async-computed.

I copied your index.d.ts into my project, and asyncComputed property warning is solved. But if I call an asyncComputed method from anywhere says:
Property 'xxx' does not exist on type 'CombinedVueInstance<Vue, { ...
(vscode)

@trollderius, you are right, that part is still missing. Let me see if I can get that to work as well.

My workaround here is using an 'any' interface, but the sad thing is all types correlations are lost.

interface AsyncComputedObject {
  [K: string]: any;
}

(this as AsyncComputedObject).xxx

I think it's quite hard to get the typings completely right here. You'd have to augment constructions like this one basically:

export interface VueConstructor<V extends Vue = Vue> {
  new <Data = object, Methods = object, Computed = object, PropNames extends string = never>(options?: ThisTypedComponentOptionsWithArrayProps<V, Data, Methods, Computed, PropNames>): CombinedVueInstance<V, Data, Methods, Computed, Record<PropNames, any>>;

I.e., add a new generic parameter ComputedAsync = object and then augment all the places where this is used. It's not impossible I think, but it won't work anymore when using some other package that does something similar. Also, it's probably quite dependent on Vue.js' exact typing setup.

So I was wondering, why is asyncComputed actually a new property in the component options? What if we marked computed properties that are "async" with an extra key instead?

This seems to work and I pushed a proof-of-concept to this PR. (We should of course not replace all the old tests, I just wanted to see that this actually works and that typescript was happy with the tests now.)

@foxbenjaminfox is there a strong reason why vue-async-computed could not support computed properties with asynchronous: true as I am doing (in this hack) here?

I am not sure whether it's possible to get the types right. My most promising attempt so far was

declare module "vue/types/options" {
	interface ComputedOptions<T> {
		asynchronous?: (() => T | Promise<T>) | {
			get: (() => T | Promise<T>);
			default?: T;
			lazy?: boolean;
		};
	}
}

With this I can set a computed's asynchronous such as

computed: {
  x: {
      asynchronous(): Promise<string> { return Promise.resolve(…) }
  }
}

and TypeScript knows that this.x is a string.

I got this to work mostly (strangely it does not work in Vue.extend.) However, there is no way to make vue-property-decorator work properly. I would have liked to be able to write a decorator such as

@asynchronous
get x() {
  return Promise.resolve(…);
}

However decorators in TypeScript can not modify the return type yet, so this did not work.

So, I am not satisfied with the current state of this and I don't have more time to invest here.